home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2002 #11 / Amiga Plus CD - 2002 - No. 11.iso / Tools / ShareMailGiftware / Frogger / plugins_src / p_ac3 / downmix.c < prev    next >
C/C++ Source or Header  |  2002-10-28  |  16KB  |  656 lines
  1. /*
  2.  * downmix.c
  3.  * Copyright (C) 2000-2002 Michel Lespinasse <walken@zoy.org>
  4.  * Copyright (C) 1999-2000 Aaron Holtzman <aholtzma@ess.engr.uvic.ca>
  5.  *
  6.  * This file is part of a52dec, a free ATSC A-52 stream decoder.
  7.  * See http://liba52.sourceforge.net/ for updates.
  8.  *
  9.  * a52dec is free software; you can redistribute it and/or modify
  10.  * it under the terms of the GNU General Public License as published by
  11.  * the Free Software Foundation; either version 2 of the License, or
  12.  * (at your option) any later version.
  13.  *
  14.  * a52dec is distributed in the hope that it will be useful,
  15.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  * GNU General Public License for more details.
  18.  *
  19.  * You should have received a copy of the GNU General Public License
  20.  * along with this program; if not, write to the Free Software
  21.  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22.  */
  23.  
  24. #include "config.h"
  25.  
  26. #include <string.h>
  27. #include <inttypes.h>
  28.  
  29. #include "a52.h"
  30. #include "a52_internal.h"
  31.  
  32. #define CONVERT(acmod,output) (((output) << 3) + (acmod))
  33.  
  34. int a52_downmix_init (int input, int flags, sample_t * level,
  35.               sample_t clev, sample_t slev)
  36. {
  37.     static uint8_t table[11][8] = {
  38.     {A52_CHANNEL,    A52_DOLBY,    A52_STEREO,    A52_STEREO,
  39.      A52_STEREO,    A52_STEREO,    A52_STEREO,    A52_STEREO},
  40.     {A52_MONO,    A52_MONO,    A52_MONO,    A52_MONO,
  41.      A52_MONO,    A52_MONO,    A52_MONO,    A52_MONO},
  42.     {A52_CHANNEL,    A52_DOLBY,    A52_STEREO,    A52_STEREO,
  43.      A52_STEREO,    A52_STEREO,    A52_STEREO,    A52_STEREO},
  44.     {A52_CHANNEL,    A52_DOLBY,    A52_STEREO,    A52_3F,
  45.      A52_STEREO,    A52_3F,        A52_STEREO,    A52_3F},
  46.     {A52_CHANNEL,    A52_DOLBY,    A52_STEREO,    A52_STEREO,
  47.      A52_2F1R,    A52_2F1R,    A52_2F1R,    A52_2F1R},
  48.     {A52_CHANNEL,    A52_DOLBY,    A52_STEREO,    A52_STEREO,
  49.      A52_2F1R,    A52_3F1R,    A52_2F1R,    A52_3F1R},
  50.     {A52_CHANNEL,    A52_DOLBY,    A52_STEREO,    A52_3F,
  51.      A52_2F2R,    A52_2F2R,    A52_2F2R,    A52_2F2R},
  52.     {A52_CHANNEL,    A52_DOLBY,    A52_STEREO,    A52_3F,
  53.      A52_2F2R,    A52_3F2R,    A52_2F2R,    A52_3F2R},
  54.     {A52_CHANNEL1,    A52_MONO,    A52_MONO,    A52_MONO,
  55.      A52_MONO,    A52_MONO,    A52_MONO,    A52_MONO},
  56.     {A52_CHANNEL2,    A52_MONO,    A52_MONO,    A52_MONO,
  57.      A52_MONO,    A52_MONO,    A52_MONO,    A52_MONO},
  58.     {A52_CHANNEL,    A52_DOLBY,    A52_STEREO,    A52_DOLBY,
  59.      A52_DOLBY,    A52_DOLBY,    A52_DOLBY,    A52_DOLBY}
  60.     };
  61.     int output;
  62.  
  63.     output = flags & A52_CHANNEL_MASK;
  64.     if (output > A52_DOLBY)
  65.     return -1;
  66.  
  67.     output = table[output][input & 7];
  68.  
  69.     if ((output == A52_STEREO) &&
  70.     ((input == A52_DOLBY) || ((input == A52_3F) && (clev == LEVEL_3DB))))
  71.     output = A52_DOLBY;
  72.  
  73.     if (flags & A52_ADJUST_LEVEL)
  74.     switch (CONVERT (input & 7, output)) {
  75.  
  76.     case CONVERT (A52_3F, A52_MONO):
  77.         *level *= LEVEL_3DB / (1 + clev);
  78.         break;
  79.  
  80.     case CONVERT (A52_STEREO, A52_MONO):
  81.     case CONVERT (A52_2F2R, A52_2F1R):
  82.     case CONVERT (A52_3F2R, A52_3F1R):
  83.     level_3db:
  84.         *level *= LEVEL_3DB;
  85.         break;
  86.  
  87.     case CONVERT (A52_3F2R, A52_2F1R):
  88.         if (clev < LEVEL_PLUS3DB - 1)
  89.         goto level_3db;
  90.         /* break thru */
  91.     case CONVERT (A52_3F, A52_STEREO):
  92.     case CONVERT (A52_3F1R, A52_2F1R):
  93.     case CONVERT (A52_3F1R, A52_2F2R):
  94.     case CONVERT (A52_3F2R, A52_2F2R):
  95.         *level /= 1 + clev;
  96.         break;
  97.  
  98.     case CONVERT (A52_2F1R, A52_MONO):
  99.         *level *= LEVEL_PLUS3DB / (2 + slev);
  100.         break;
  101.  
  102.     case CONVERT (A52_2F1R, A52_STEREO):
  103.     case CONVERT (A52_3F1R, A52_3F):
  104.         *level /= 1 + slev * LEVEL_3DB;
  105.         break;
  106.  
  107.     case CONVERT (A52_3F1R, A52_MONO):
  108.         *level *= LEVEL_3DB / (1 + clev + 0.5 * slev);
  109.         break;
  110.  
  111.     case CONVERT (A52_3F1R, A52_STEREO):
  112.         *level /= 1 + clev + slev * LEVEL_3DB;
  113.         break;
  114.  
  115.     case CONVERT (A52_2F2R, A52_MONO):
  116.         *level *= LEVEL_3DB / (1 + slev);
  117.         break;
  118.  
  119.     case CONVERT (A52_2F2R, A52_STEREO):
  120.     case CONVERT (A52_3F2R, A52_3F):
  121.         *level /= 1 + slev;
  122.         break;
  123.  
  124.     case CONVERT (A52_3F2R, A52_MONO):
  125.         *level *= LEVEL_3DB / (1 + clev + slev);
  126.         break;
  127.  
  128.     case CONVERT (A52_3F2R, A52_STEREO):
  129.         *level /= 1 + clev + slev;
  130.         break;
  131.  
  132.     case CONVERT (A52_MONO, A52_DOLBY):
  133.         *level *= LEVEL_PLUS3DB;
  134.         break;
  135.  
  136.     case CONVERT (A52_3F, A52_DOLBY):
  137.     case CONVERT (A52_2F1R, A52_DOLBY):
  138.         *level *= 1 / (1 + LEVEL_3DB);
  139.         break;
  140.  
  141.     case CONVERT (A52_3F1R, A52_DOLBY):
  142.     case CONVERT (A52_2F2R, A52_DOLBY):
  143.         *level *= 1 / (1 + 2 * LEVEL_3DB);
  144.         break;
  145.  
  146.     case CONVERT (A52_3F2R, A52_DOLBY):
  147.         *level *= 1 / (1 + 3 * LEVEL_3DB);
  148.         break;
  149.     }
  150.  
  151.     return output;
  152. }
  153.  
  154. int a52_downmix_coeff (sample_t * coeff, int acmod, int output, sample_t level,
  155.                sample_t clev, sample_t slev)
  156. {
  157.     switch (CONVERT (acmod, output & A52_CHANNEL_MASK)) {
  158.  
  159.     case CONVERT (A52_CHANNEL, A52_CHANNEL):
  160.     case CONVERT (A52_MONO, A52_MONO):
  161.     case CONVERT (A52_STEREO, A52_STEREO):
  162.     case CONVERT (A52_3F, A52_3F):
  163.     case CONVERT (A52_2F1R, A52_2F1R):
  164.     case CONVERT (A52_3F1R, A52_3F1R):
  165.     case CONVERT (A52_2F2R, A52_2F2R):
  166.     case CONVERT (A52_3F2R, A52_3F2R):
  167.     case CONVERT (A52_STEREO, A52_DOLBY):
  168.     coeff[0] = coeff[1] = coeff[2] = coeff[3] = coeff[4] = level;
  169.     return 0;
  170.  
  171.     case CONVERT (A52_CHANNEL, A52_MONO):
  172.     coeff[0] = coeff[1] = level * LEVEL_6DB;
  173.     return 3;
  174.  
  175.     case CONVERT (A52_STEREO, A52_MONO):
  176.     coeff[0] = coeff[1] = level * LEVEL_3DB;
  177.     return 3;
  178.  
  179.     case CONVERT (A52_3F, A52_MONO):
  180.     coeff[0] = coeff[2] = level * LEVEL_3DB;
  181.     coeff[1] = level * clev * LEVEL_PLUS3DB;
  182.     return 7;
  183.  
  184.     case CONVERT (A52_2F1R, A52_MONO):
  185.     coeff[0] = coeff[1] = level * LEVEL_3DB;
  186.     coeff[2] = level * slev * LEVEL_3DB;
  187.     return 7;
  188.  
  189.     case CONVERT (A52_2F2R, A52_MONO):
  190.     coeff[0] = coeff[1] = level * LEVEL_3DB;
  191.     coeff[2] = coeff[3] = level * slev * LEVEL_3DB;
  192.     return 15;
  193.  
  194.     case CONVERT (A52_3F1R, A52_MONO):
  195.     coeff[0] = coeff[2] = level * LEVEL_3DB;
  196.     coeff[1] = level * clev * LEVEL_PLUS3DB;
  197.     coeff[3] = level * slev * LEVEL_3DB;
  198.     return 15;
  199.  
  200.     case CONVERT (A52_3F2R, A52_MONO):
  201.     coeff[0] = coeff[2] = level * LEVEL_3DB;
  202.     coeff[1] = level * clev * LEVEL_PLUS3DB;
  203.     coeff[3] = coeff[4] = level * slev * LEVEL_3DB;
  204.     return 31;
  205.  
  206.     case CONVERT (A52_MONO, A52_DOLBY):
  207.     coeff[0] = level * LEVEL_3DB;
  208.     return 0;
  209.  
  210.     case CONVERT (A52_3F, A52_DOLBY):
  211.     clev = LEVEL_3DB;
  212.     case CONVERT (A52_3F, A52_STEREO):
  213.     case CONVERT (A52_3F1R, A52_2F1R):
  214.     case CONVERT (A52_3F2R, A52_2F2R):
  215.     coeff[0] = coeff[2] = coeff[3] = coeff[4] = level;
  216.     coeff[1] = level * clev;
  217.     return 7;
  218.  
  219.     case CONVERT (A52_2F1R, A52_DOLBY):
  220.     slev = 1;
  221.     case CONVERT (A52_2F1R, A52_STEREO):
  222.     coeff[0] = coeff[1] = level;
  223.     coeff[2] = level * slev * LEVEL_3DB;
  224.     return 7;
  225.  
  226.     case CONVERT (A52_3F1R, A52_DOLBY):
  227.     clev = LEVEL_3DB;
  228.     slev = 1;
  229.     case CONVERT (A52_3F1R, A52_STEREO):
  230.     coeff[0] = coeff[2] = level;
  231.     coeff[1] = level * clev;
  232.     coeff[3] = level * slev * LEVEL_3DB;
  233.     return 15;
  234.  
  235.     case CONVERT (A52_2F2R, A52_DOLBY):
  236.     slev = LEVEL_3DB;
  237.     case CONVERT (A52_2F2R, A52_STEREO):
  238.     coeff[0] = coeff[1] = level;
  239.     coeff[2] = coeff[3] = level * slev;
  240.     return 15;
  241.  
  242.     case CONVERT (A52_3F2R, A52_DOLBY):
  243.     clev = LEVEL_3DB;
  244.     case CONVERT (A52_3F2R, A52_2F1R):
  245.     slev = LEVEL_3DB;
  246.     case CONVERT (A52_3F2R, A52_STEREO):
  247.     coeff[0] = coeff[2] = level;
  248.     coeff[1] = level * clev;
  249.     coeff[3] = coeff[4] = level * slev;
  250.     return 31;
  251.  
  252.     case CONVERT (A52_3F1R, A52_3F):
  253.     coeff[0] = coeff[1] = coeff[2] = level;
  254.     coeff[3] = level * slev * LEVEL_3DB;
  255.     return 13;
  256.  
  257.     case CONVERT (A52_3F2R, A52_3F):
  258.     coeff[0] = coeff[1] = coeff[2] = level;
  259.     coeff[3] = coeff[4] = level * slev;
  260.     return 29;
  261.  
  262.     case CONVERT (A52_2F2R, A52_2F1R):
  263.     coeff[0] = coeff[1] = level;
  264.     coeff[2] = coeff[3] = level * LEVEL_3DB;
  265.     return 12;
  266.  
  267.     case CONVERT (A52_3F2R, A52_3F1R):
  268.     coeff[0] = coeff[1] = coeff[2] = level;
  269.     coeff[3] = coeff[4] = level * LEVEL_3DB;
  270.     return 24;
  271.  
  272.     case CONVERT (A52_2F1R, A52_2F2R):
  273.     coeff[0] = coeff[1] = level;
  274.     coeff[2] = level * LEVEL_3DB;
  275.     return 0;
  276.  
  277.     case CONVERT (A52_3F1R, A52_2F2R):
  278.     coeff[0] = coeff[2] = level;
  279.     coeff[1] = level * clev;
  280.     coeff[3] = level * LEVEL_3DB;
  281.     return 7;
  282.  
  283.     case CONVERT (A52_3F1R, A52_3F2R):
  284.     coeff[0] = coeff[1] = coeff[2] = level;
  285.     coeff[3] = level * LEVEL_3DB;
  286.     return 0;
  287.  
  288.     case CONVERT (A52_CHANNEL, A52_CHANNEL1):
  289.     coeff[0] = level;
  290.     coeff[1] = 0;
  291.     return 0;
  292.  
  293.     case CONVERT (A52_CHANNEL, A52_CHANNEL2):
  294.     coeff[0] = 0;
  295.     coeff[1] = level;
  296.     return 0;
  297.     }
  298.  
  299.     return -1;    /* NOTREACHED */
  300. }
  301.  
  302. static void mix2to1 (sample_t * dest, sample_t * src, sample_t bias)
  303. {
  304.     int i;
  305.  
  306.     for (i = 0; i < 256; i++)
  307.     dest[i] += src[i] + bias;
  308. }
  309.  
  310. static void mix3to1 (sample_t * samples, sample_t bias)
  311. {
  312.     int i;
  313.  
  314.     for (i = 0; i < 256; i++)
  315.     samples[i] += samples[i + 256] + samples[i + 512] + bias;
  316. }
  317.  
  318. static void mix4to1 (sample_t * samples, sample_t bias)
  319. {
  320.     int i;
  321.  
  322.     for (i = 0; i < 256; i++)
  323.     samples[i] += (samples[i + 256] + samples[i + 512] +
  324.                samples[i + 768] + bias);
  325. }
  326.  
  327. static void mix5to1 (sample_t * samples, sample_t bias)
  328. {
  329.     int i;
  330.  
  331.     for (i = 0; i < 256; i++)
  332.     samples[i] += (samples[i + 256] + samples[i + 512] +
  333.                samples[i + 768] + samples[i + 1024] + bias);
  334. }
  335.  
  336. static void mix3to2 (sample_t * samples, sample_t bias)
  337. {
  338.     int i;
  339.     sample_t common;
  340.  
  341.     for (i = 0; i < 256; i++) {
  342.     common = samples[i + 256] + bias;
  343.     samples[i] += common;
  344.     samples[i + 256] = samples[i + 512] + common;
  345.     }
  346. }
  347.  
  348. static void mix21to2 (sample_t * left, sample_t * right, sample_t bias)
  349. {
  350.     int i;
  351.     sample_t common;
  352.  
  353.     for (i = 0; i < 256; i++) {
  354.     common = right[i + 256] + bias;
  355.     left[i] += common;
  356.     right[i] += common;
  357.     }
  358. }
  359.  
  360. static void mix21toS (sample_t * samples, sample_t bias)
  361. {
  362.     int i;
  363.     sample_t surround;
  364.  
  365.     for (i = 0; i < 256; i++) {
  366.     surround = samples[i + 512];
  367.     samples[i] += bias - surround;
  368.     samples[i + 256] += bias + surround;
  369.     }
  370. }
  371.  
  372. static void mix31to2 (sample_t * samples, sample_t bias)
  373. {
  374.     int i;
  375.     sample_t common;
  376.  
  377.     for (i = 0; i < 256; i++) {
  378.     common = samples[i + 256] + samples[i + 768] + bias;
  379.     samples[i] += common;
  380.     samples[i + 256] = samples[i + 512] + common;
  381.     }
  382. }
  383.  
  384. static void mix31toS (sample_t * samples, sample_t bias)
  385. {
  386.     int i;
  387.     sample_t common, surround;
  388.  
  389.     for (i = 0; i < 256; i++) {
  390.     common = samples[i + 256] + bias;
  391.     surround = samples[i + 768];
  392.     samples[i] += common - surround;
  393.     samples[i + 256] = samples[i + 512] + common + surround;
  394.     }
  395. }
  396.  
  397. static void mix22toS (sample_t * samples, sample_t bias)
  398. {
  399.     int i;
  400.     sample_t surround;
  401.  
  402.     for (i = 0; i < 256; i++) {
  403.     surround = samples[i + 512] + samples[i + 768];
  404.     samples[i] += bias - surround;
  405.     samples[i + 256] += bias + surround;
  406.     }
  407. }
  408.  
  409. static void mix32to2 (sample_t * samples, sample_t bias)
  410. {
  411.     int i;
  412.     sample_t common;
  413.  
  414.     for (i = 0; i < 256; i++) {
  415.     common = samples[i + 256] + bias;
  416.     samples[i] += common + samples[i + 768];
  417.     samples[i + 256] = common + samples[i + 512] + samples[i + 1024];
  418.     }
  419. }
  420.  
  421. static void mix32toS (sample_t * samples, sample_t bias)
  422. {
  423.     int i;
  424.     sample_t common, surround;
  425.  
  426.     for (i = 0; i < 256; i++) {
  427.     common = samples[i + 256] + bias;
  428.     surround = samples[i + 768] + samples[i + 1024];
  429.     samples[i] += common - surround;
  430.     samples[i + 256] = samples[i + 512] + common + surround;
  431.     }
  432. }
  433.  
  434. static void move2to1 (sample_t * src, sample_t * dest, sample_t bias)
  435. {
  436.     int i;
  437.  
  438.     for (i = 0; i < 256; i++)
  439.     dest[i] = src[i] + src[i + 256] + bias;
  440. }
  441.  
  442. static void zero (sample_t * samples)
  443. {
  444.     int i;
  445.  
  446.     for (i = 0; i < 256; i++)
  447.     samples[i] = 0;
  448. }
  449.  
  450. void a52_downmix (sample_t * samples, int acmod, int output, sample_t bias,
  451.           sample_t clev, sample_t slev)
  452. {
  453.     switch (CONVERT (acmod, output & A52_CHANNEL_MASK)) {
  454.  
  455.     case CONVERT (A52_CHANNEL, A52_CHANNEL2):
  456.     memcpy (samples, samples + 256, 256 * sizeof (sample_t));
  457.     break;
  458.  
  459.     case CONVERT (A52_CHANNEL, A52_MONO):
  460.     case CONVERT (A52_STEREO, A52_MONO):
  461.     mix_2to1:
  462.     mix2to1 (samples, samples + 256, bias);
  463.     break;
  464.  
  465.     case CONVERT (A52_2F1R, A52_MONO):
  466.     if (slev == 0)
  467.         goto mix_2to1;
  468.     case CONVERT (A52_3F, A52_MONO):
  469.     mix_3to1:
  470.     mix3to1 (samples, bias);
  471.     break;
  472.  
  473.     case CONVERT (A52_3F1R, A52_MONO):
  474.     if (slev == 0)
  475.         goto mix_3to1;
  476.     case CONVERT (A52_2F2R, A52_MONO):
  477.     if (slev == 0)
  478.         goto mix_2to1;
  479.     mix4to1 (samples, bias);
  480.     break;
  481.  
  482.     case CONVERT (A52_3F2R, A52_MONO):
  483.     if (slev == 0)
  484.         goto mix_3to1;
  485.     mix5to1 (samples, bias);
  486.     break;
  487.  
  488.     case CONVERT (A52_MONO, A52_DOLBY):
  489.     memcpy (samples + 256, samples, 256 * sizeof (sample_t));
  490.     break;
  491.  
  492.     case CONVERT (A52_3F, A52_STEREO):
  493.     case CONVERT (A52_3F, A52_DOLBY):
  494.     mix_3to2:
  495.     mix3to2 (samples, bias);
  496.     break;
  497.  
  498.     case CONVERT (A52_2F1R, A52_STEREO):
  499.     if (slev == 0)
  500.         break;
  501.     mix21to2 (samples, samples + 256, bias);
  502.     break;
  503.  
  504.     case CONVERT (A52_2F1R, A52_DOLBY):
  505.     mix21toS (samples, bias);
  506.     break;
  507.  
  508.     case CONVERT (A52_3F1R, A52_STEREO):
  509.     if (slev == 0)
  510.         goto mix_3to2;
  511.     mix31to2 (samples, bias);
  512.     break;
  513.  
  514.     case CONVERT (A52_3F1R, A52_DOLBY):
  515.     mix31toS (samples, bias);
  516.     break;
  517.  
  518.     case CONVERT (A52_2F2R, A52_STEREO):
  519.     if (slev == 0)
  520.         break;
  521.     mix2to1 (samples, samples + 512, bias);
  522.     mix2to1 (samples + 256, samples + 768, bias);
  523.     break;
  524.  
  525.     case CONVERT (A52_2F2R, A52_DOLBY):
  526.     mix22toS (samples, bias);
  527.     break;
  528.  
  529.     case CONVERT (A52_3F2R, A52_STEREO):
  530.     if (slev == 0)
  531.         goto mix_3to2;
  532.     mix32to2 (samples, bias);
  533.     break;
  534.  
  535.     case CONVERT (A52_3F2R, A52_DOLBY):
  536.     mix32toS (samples, bias);
  537.     break;
  538.  
  539.     case CONVERT (A52_3F1R, A52_3F):
  540.     if (slev == 0)
  541.         break;
  542.     mix21to2 (samples, samples + 512, bias);
  543.     break;
  544.  
  545.     case CONVERT (A52_3F2R, A52_3F):
  546.     if (slev == 0)
  547.         break;
  548.     mix2to1 (samples, samples + 768, bias);
  549.     mix2to1 (samples + 512, samples + 1024, bias);
  550.     break;
  551.  
  552.     case CONVERT (A52_3F1R, A52_2F1R):
  553.     mix3to2 (samples, bias);
  554.     memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
  555.     break;
  556.  
  557.     case CONVERT (A52_2F2R, A52_2F1R):
  558.     mix2to1 (samples + 512, samples + 768, bias);
  559.     break;
  560.  
  561.     case CONVERT (A52_3F2R, A52_2F1R):
  562.     mix3to2 (samples, bias);
  563.     move2to1 (samples + 768, samples + 512, bias);
  564.     break;
  565.  
  566.     case CONVERT (A52_3F2R, A52_3F1R):
  567.     mix2to1 (samples + 768, samples + 1024, bias);
  568.     break;
  569.  
  570.     case CONVERT (A52_2F1R, A52_2F2R):
  571.     memcpy (samples + 768, samples + 512, 256 * sizeof (sample_t));
  572.     break;
  573.  
  574.     case CONVERT (A52_3F1R, A52_2F2R):
  575.     mix3to2 (samples, bias);
  576.     memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
  577.     break;
  578.  
  579.     case CONVERT (A52_3F2R, A52_2F2R):
  580.     mix3to2 (samples, bias);
  581.     memcpy (samples + 512, samples + 768, 256 * sizeof (sample_t));
  582.     memcpy (samples + 768, samples + 1024, 256 * sizeof (sample_t));
  583.     break;
  584.  
  585.     case CONVERT (A52_3F1R, A52_3F2R):
  586.     memcpy (samples + 1027, samples + 768, 256 * sizeof (sample_t));
  587.     break;
  588.     }
  589. }
  590.  
  591. void a52_upmix (sample_t * samples, int acmod, int output)
  592. {
  593.     switch (CONVERT (acmod, output & A52_CHANNEL_MASK)) {
  594.  
  595.     case CONVERT (A52_CHANNEL, A52_CHANNEL2):
  596.     memcpy (samples + 256, samples, 256 * sizeof (sample_t));
  597.     break;
  598.  
  599.     case CONVERT (A52_3F2R, A52_MONO):
  600.     zero (samples + 1024);
  601.     case CONVERT (A52_3F1R, A52_MONO):
  602.     case CONVERT (A52_2F2R, A52_MONO):
  603.     zero (samples + 768);
  604.     case CONVERT (A52_3F, A52_MONO):
  605.     case CONVERT (A52_2F1R, A52_MONO):
  606.     zero (samples + 512);
  607.     case CONVERT (A52_CHANNEL, A52_MONO):
  608.     case CONVERT (A52_STEREO, A52_MONO):
  609.     zero (samples + 256);
  610.     break;
  611.  
  612.     case CONVERT (A52_3F2R, A52_STEREO):
  613.     case CONVERT (A52_3F2R, A52_DOLBY):
  614.     zero (samples + 1024);
  615.     case CONVERT (A52_3F1R, A52_STEREO):
  616.     case CONVERT (A52_3F1R, A52_DOLBY):
  617.     zero (samples + 768);
  618.     case CONVERT (A52_3F, A52_STEREO):
  619.     case CONVERT (A52_3F, A52_DOLBY):
  620.     mix_3to2:
  621.     memcpy (samples + 512, samples + 256, 256 * sizeof (sample_t));
  622.     zero (samples + 256);
  623.     break;
  624.  
  625.     case CONVERT (A52_2F2R, A52_STEREO):
  626.     case CONVERT (A52_2F2R, A52_DOLBY):
  627.     zero (samples + 768);
  628.     case CONVERT (A52_2F1R, A52_STEREO):
  629.     case CONVERT (A52_2F1R, A52_DOLBY):
  630.     zero (samples + 512);
  631.     break;
  632.  
  633.     case CONVERT (A52_3F2R, A52_3F):
  634.     zero (samples + 1024);
  635.     case CONVERT (A52_3F1R, A52_3F):
  636.     case CONVERT (A52_2F2R, A52_2F1R):
  637.     zero (samples + 768);
  638.     break;
  639.  
  640.     case CONVERT (A52_3F2R, A52_3F1R):
  641.     zero (samples + 1024);
  642.     break;
  643.  
  644.     case CONVERT (A52_3F2R, A52_2F1R):
  645.     zero (samples + 1024);
  646.     case CONVERT (A52_3F1R, A52_2F1R):
  647.     mix_31to21:
  648.     memcpy (samples + 768, samples + 512, 256 * sizeof (sample_t));
  649.     goto mix_3to2;
  650.  
  651.     case CONVERT (A52_3F2R, A52_2F2R):
  652.     memcpy (samples + 1024, samples + 768, 256 * sizeof (sample_t));
  653.     goto mix_31to21;
  654.     }
  655. }
  656.